home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / JFC.bin / MetalToolBarUI.java < prev    next >
Text File  |  1998-06-30  |  8KB  |  361 lines
  1. /*
  2.  * @(#)MetalToolBarUI.java    1.5 98/04/09
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20.  
  21. package com.sun.java.swing.plaf.metal;
  22.  
  23. import com.sun.java.swing.*;
  24. import java.awt.Color;
  25. import java.awt.Component;
  26. import java.awt.Container;
  27. import java.awt.Dimension;
  28. import java.awt.Frame;
  29. import java.awt.Graphics;
  30. import java.awt.Insets;
  31. import java.awt.Point;
  32. import java.awt.Rectangle;
  33. import java.awt.event.*;
  34. import java.util.*;
  35.  
  36. import java.io.Serializable;
  37.  
  38. import java.beans.PropertyChangeListener;
  39. import java.beans.PropertyChangeEvent;
  40. import java.beans.PropertyVetoException;
  41.  
  42. import com.sun.java.swing.border.*;
  43. import com.sun.java.swing.plaf.*;
  44. import com.sun.java.swing.plaf.basic.*;
  45.  
  46. /**
  47.  * A Metal Look and Feel implementation of ToolBarUI.  This implementation 
  48.  * is a "combined" view/controller.
  49.  * <p>
  50.  * Warning: serialized objects of this class will not be compatible with
  51.  * future swing releases.  The current serialization support is appropriate
  52.  * for short term storage or RMI between Swing1.0 applications.  It will
  53.  * not be possible to load serialized Swing1.0 objects with future releases
  54.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  55.  * baseline for the serialized form of Swing objects.
  56.  *
  57.  * @version 1.5 04/09/98
  58.  * @author Jeff Shapiro
  59.  */
  60. public class MetalToolBarUI extends BasicToolBarUI implements ContainerListener
  61. {
  62.     protected static Border rolloverBorder = new MetalRolloverButtonBorder();
  63.  
  64.     protected static Border nonRolloverBorder = new MetalButtonBorder();
  65.  
  66.     protected Hashtable borderTable = new Hashtable();
  67.  
  68.     protected ContainerListener contListener;
  69.  
  70.     private boolean rolloverBorders = false;
  71.  
  72.     private PropertyChangeListener rolloverListener;
  73.  
  74.     protected static String IS_ROLLOVER = "JToolBar.isRollover";
  75.  
  76.     public static ComponentUI createUI( JComponent c )
  77.     {
  78.     return new MetalToolBarUI();
  79.     }
  80.  
  81.     public void installUI( JComponent c )
  82.     {
  83.         rolloverListener = new RolloverListener();
  84.     c.addPropertyChangeListener( rolloverListener );
  85.  
  86.         super.installUI( c );
  87.  
  88.     Object rolloverProp = c.getClientProperty( IS_ROLLOVER );
  89.  
  90.     if ( rolloverProp != null )
  91.     {
  92.         setRolloverBorders( ((Boolean)rolloverProp).booleanValue() );
  93.     }
  94.     else
  95.     {
  96.         setRolloverBorders( false );
  97.     }
  98.     }
  99.  
  100.     public void uninstallUI( JComponent c )
  101.     {
  102.         c.removePropertyChangeListener( rolloverListener );
  103.  
  104.         super.uninstallUI( c );
  105.  
  106.     installNormalBorders( c );
  107.    }
  108.  
  109.     protected void installListeners( JComponent c )
  110.     {
  111.         super.installListeners( c );
  112.  
  113.         if ( (contListener = createContainerListener(c)) != null )
  114.     {
  115.             c.addContainerListener( contListener );
  116.         }
  117.     }
  118.  
  119.     protected void uninstallListeners( JComponent c )
  120.     {
  121.         super.uninstallListeners( c );
  122.  
  123.         if ( contListener != null )
  124.     {
  125.             c.removeContainerListener( contListener );
  126.             contListener = null;
  127.         }
  128.     }
  129.  
  130.     protected ContainerListener createContainerListener( JComponent c )
  131.     {
  132.         return this;
  133.     }
  134.  
  135.     protected DockingListener createDockingListener( JToolBar toolbar )
  136.     {
  137.     return new MetalDockingListener( toolbar );
  138.     }
  139.  
  140.     protected void setDragOffset( Point p )
  141.     {
  142.         if (dragWindow == null)
  143.         dragWindow = createDragWindow(toolBar);
  144.  
  145.         dragWindow.setOffset( p );
  146.     }
  147.  
  148.     public boolean isRolloverBorders()
  149.     {
  150.         return rolloverBorders;
  151.     }
  152.  
  153.     public void setRolloverBorders( boolean rollover )
  154.     {
  155.         rolloverBorders = rollover;
  156.         
  157.     if ( rolloverBorders )
  158.     {
  159.         installRolloverBorders( toolBar );
  160.     }
  161.     else
  162.     {
  163.         installNonRolloverBorders( toolBar );
  164.     }
  165.     }
  166.  
  167.     protected void installRolloverBorders ( JComponent c )
  168.     {
  169.     // Put rollover borders on buttons
  170.     Component[] components = c.getComponents();
  171.  
  172.     for ( int i = 0; i < components.length; ++i )
  173.     {
  174.       if ( components[ i ] instanceof JComponent )
  175.       {
  176.           ( (JComponent)components[ i ] ).updateUI();
  177.  
  178.           setBorderToRollover( components[ i ] );
  179.       }
  180.     }
  181.     }
  182.  
  183.     protected void installNonRolloverBorders ( JComponent c )
  184.     {
  185.     // Put nonrollover borders on buttons
  186.     Component[] components = c.getComponents();
  187.  
  188.     for ( int i = 0; i < components.length; ++i )
  189.     {
  190.       if ( components[ i ] instanceof JComponent )
  191.       {
  192.           ( (JComponent)components[ i ] ).updateUI();
  193.  
  194.           setBorderToNonRollover( components[ i ] );
  195.       }
  196.     }
  197.     }
  198.  
  199.     protected void installNormalBorders ( JComponent c )
  200.     {
  201.     // Put back the normal borders on buttons
  202.     Component[] components = c.getComponents();
  203.  
  204.     for ( int i = 0; i < components.length; ++i )
  205.     {
  206.         setBorderToNormal( components[ i ] );
  207.     }
  208.     }
  209.  
  210.     protected void setBorderToRollover( Component c )
  211.     {
  212.         if ( c instanceof JButton )
  213.     {
  214.         JButton b = (JButton)c;
  215.  
  216.         if ( b.getUI() instanceof MetalButtonUI )
  217.         {
  218.             if ( b.getBorder() instanceof UIResource )
  219.         {
  220.             borderTable.put( b, b.getBorder() );
  221.         }
  222.  
  223.         if ( b.getBorder() instanceof UIResource || b.getBorder() == nonRolloverBorder )
  224.         {
  225.             b.setBorder( rolloverBorder );
  226.         }
  227.         
  228.         b.setRolloverEnabled( true );
  229.         }
  230.     }
  231.     }
  232.  
  233.     protected void setBorderToNonRollover( Component c )
  234.     {
  235.         if ( c instanceof JButton )
  236.     {
  237.         JButton b = (JButton)c;
  238.  
  239.         if ( b.getUI() instanceof MetalButtonUI )
  240.         {
  241.             if ( b.getBorder() instanceof UIResource )
  242.         {
  243.             borderTable.put( b, b.getBorder() );
  244.         }
  245.  
  246.         if ( b.getBorder() instanceof UIResource || b.getBorder() == rolloverBorder )
  247.         {
  248.             b.setBorder( nonRolloverBorder );
  249.         }
  250.  
  251.         b.setRolloverEnabled( false );
  252.         }
  253.     }
  254.     }
  255.  
  256.     protected void setBorderToNormal( Component c )
  257.     {
  258.         if ( c instanceof JButton )
  259.     {
  260.         JButton b = (JButton)c;
  261.  
  262.         if ( b.getUI() instanceof MetalButtonUI )
  263.         {
  264.             if ( b.getBorder() == rolloverBorder || b.getBorder() == nonRolloverBorder )
  265.         {
  266.             b.setBorder( (Border)borderTable.remove( b ) );
  267.         }
  268.  
  269.         b.setRolloverEnabled( false );
  270.         }
  271.     }
  272.     }
  273.  
  274.     // ContainerListener overrides
  275.  
  276.     public void componentAdded( ContainerEvent e )
  277.     {
  278.         Component c = e.getChild();
  279.  
  280.         if ( rolloverBorders )
  281.     {
  282.         setBorderToRollover( c );
  283.     }
  284.     else
  285.     {
  286.         setBorderToNonRollover( c );
  287.     }
  288.     }
  289.  
  290.     public void componentRemoved( ContainerEvent e )
  291.     {
  292.         Component c = e.getChild();
  293.     setBorderToNormal( c );
  294.     }
  295.  
  296.     class RolloverListener implements PropertyChangeListener, Serializable
  297.     {
  298.         public void propertyChange( PropertyChangeEvent e )
  299.     {
  300.         String name = e.getPropertyName();
  301.  
  302.         if ( name.equals( IS_ROLLOVER ) )
  303.         {
  304.             if ( e.getNewValue() != null )
  305.         {
  306.             setRolloverBorders( ((Boolean)e.getNewValue()).booleanValue() );
  307.         }
  308.         else
  309.         {
  310.             setRolloverBorders( false );
  311.         }
  312.         }
  313.     }
  314.     } // end class RolloverListener
  315.  
  316.     protected class MetalDockingListener extends DockingListener
  317.     {
  318.         protected boolean pressedInBumps = false;
  319.  
  320.     public MetalDockingListener( JToolBar t )
  321.     {
  322.         super( t );
  323.     } 
  324.  
  325.     public void mousePressed( MouseEvent e )
  326.     { 
  327.         super.mousePressed( e );
  328.         setDragOffset( e.getPoint() );
  329.         pressedInBumps = false;
  330.  
  331.         Rectangle bumpRect = new Rectangle();
  332.  
  333.         if ( toolBar.getSize().height <= toolBar.getSize().width )  // horizontal
  334.         {
  335.         bumpRect.setBounds( 0, 0, 14, toolBar.getSize().height );
  336.         }
  337.         else  // vertical
  338.         {
  339.         bumpRect.setBounds( 0, 0, toolBar.getSize().width, 14 );
  340.         }
  341.  
  342.         if ( bumpRect.contains( e.getPoint() ) )
  343.         {
  344.             pressedInBumps = true;
  345.         }
  346.     }
  347.  
  348.     public void mouseDragged( MouseEvent e )
  349.     {
  350.         if ( pressedInBumps )
  351.         {
  352.             super.mouseDragged( e );
  353.         }
  354.     }
  355.  
  356.     } // end class MetalDockingListener
  357.  
  358. }
  359.  
  360.  
  361.